home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / 56ktools / dspkgctr.z / dspkgctr / gcc / fold-const.c < prev    next >
C/C++ Source or Header  |  1992-06-08  |  49KB  |  1,845 lines
  1. /* Fold a constant sub-tree into a single node for C-compiler
  2.    Copyright (C) 1987, 1988 Free Software Foundation, Inc.
  3.  
  4.    $Id: fold-const.c,v 1.3 91/10/23 16:40:36 pete Exp $
  5.  
  6. This file is part of GNU CC.
  7.  
  8. GNU CC is free software; you can redistribute it and/or modify
  9. it under the terms of the GNU General Public License as published by
  10. the Free Software Foundation; either version 1, or (at your option)
  11. any later version.
  12.  
  13. GNU CC is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU General Public License for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with GNU CC; see the file COPYING.  If not, write to
  20. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21.  
  22. /*@@ Fix lossage on folding division of big integers.  */
  23.  
  24. /*@@ This file should be rewritten to use an arbitary precision
  25.   @@ representation for "struct tree_int_cst" and "struct tree_real_cst".
  26.   @@ Perhaps the routines could also be used for bc/dc, and made a lib.
  27.   @@ The routines that translate from the ap rep should
  28.   @@ warn if precision et. al. is lost.
  29.   @@ This would also make life easier when this technology is used
  30.   @@ for cross-compilers.  */
  31.  
  32.  
  33. /* There are only two entry points in this file:
  34.    fold and combine.
  35.  
  36.    fold takes a tree as argument and returns a simplified tree.
  37.  
  38.    combine takes a tree code for an arithmetic operation
  39.    and two operands that are trees for constant values
  40.    and returns the result of the specified operation on those values,
  41.    also as a tree.  */
  42.    
  43. #include <stdio.h>
  44. #include <setjmp.h>
  45. #include "config.h"
  46. #include "tree.h"
  47.  
  48. #if defined( _MSDOS )
  49. void warning ( char * s, ... );
  50. #endif
  51.  
  52. static void lshift_double ();
  53. static void rshift_double ();
  54. static void lrotate_double ();
  55. static void rrotate_double ();
  56.  
  57. /* To do constant folding on INTEGER_CST nodes requires 64-bit arithmetic.
  58.    We do that by representing the 64-bit integer as 8 shorts,
  59.    with only 8 bits stored in each short, as a positive number.  */
  60.  
  61. /* Unpack a 64-bit integer into 8 shorts.
  62.    LOW and HI are the integer, as two `int' pieces.
  63.    SHORTS points to the array of shorts.  */
  64.  
  65. static void
  66. encode (shorts, low, hi)
  67.      short *shorts;
  68.      int low, hi;
  69. {
  70.   shorts[0] = low & 0xff;
  71.   shorts[1] = (low >> 8) & 0xff;
  72.   shorts[2] = (low >> 16) & 0xff;
  73.   shorts[3] = (low >> 24) & 0xff;
  74.   shorts[4] = hi & 0xff;
  75.   shorts[5] = (hi >> 8) & 0xff;
  76.   shorts[6] = (hi >> 16) & 0xff;
  77.   shorts[7] = (hi >> 24) & 0xff;
  78. }
  79.  
  80. /* Pack an array of 8 shorts into a 64-bit integer.
  81.    SHORTS points to the array of shorts.
  82.    The integer is stored into *LOW and *HI as two `int' pieces.  */
  83.  
  84. static void
  85. decode (shorts, low, hi)
  86.      short *shorts;
  87.      int *low, *hi;
  88. {
  89.   *low = (shorts[3] << 24) | (shorts[2] << 16) | (shorts[1] << 8) | shorts[0];
  90.   *hi = (shorts[7] << 24) | (shorts[6] << 16) | (shorts[5] << 8) | shorts[4];
  91. }
  92.  
  93. /* Make the integer constant T valid for its type
  94.    by setting to 0 or 1 all the bits in the constant
  95.    that don't belong in the type.  */
  96.  
  97. static void
  98. force_fit_type (t)
  99.      tree t;
  100. {
  101.   register int prec = TYPE_PRECISION (TREE_TYPE (t));
  102.  
  103.   if (TREE_CODE (TREE_TYPE (t)) == POINTER_TYPE)
  104.     prec = BITS_PER_WORD;
  105.  
  106.   /* First clear all bits that are beyond the type's precision.  */
  107.  
  108.   if (prec == 2 * HOST_BITS_PER_INT)
  109.     ;
  110.   else if (prec > HOST_BITS_PER_INT)
  111.     {
  112.       TREE_INT_CST_HIGH (t)
  113.     &= ~((-1) << (prec - HOST_BITS_PER_INT));
  114.     }
  115.   else
  116.     {
  117.       TREE_INT_CST_HIGH (t) = 0;
  118.       if (prec < HOST_BITS_PER_INT)
  119.     TREE_INT_CST_LOW (t)
  120.       &= ~((-1) << prec);
  121.     }
  122.  
  123.   /* If it's a signed type and value's sign bit is set, extend the sign.  */
  124.  
  125.   if (! TREE_UNSIGNED (TREE_TYPE (t))
  126.       && prec != 2 * HOST_BITS_PER_INT
  127.       && (prec > HOST_BITS_PER_INT
  128.       ? TREE_INT_CST_HIGH (t) & (1 << (prec - HOST_BITS_PER_INT - 1))
  129.       : TREE_INT_CST_LOW (t) & (1 << (prec - 1))))
  130.     {
  131.       /* Value is negative:
  132.      set to 1 all the bits that are outside this type's precision.  */
  133.       if (prec > HOST_BITS_PER_INT)
  134.     {
  135.       TREE_INT_CST_HIGH (t)
  136.         |= ((-1) << (prec - HOST_BITS_PER_INT));
  137.     }
  138.       else
  139.     {
  140.       TREE_INT_CST_HIGH (t) = -1;
  141.       if (prec < HOST_BITS_PER_INT)
  142.         TREE_INT_CST_LOW (t)
  143.           |= ((-1) << prec);
  144.     }
  145.     }
  146. }
  147.  
  148. /* Add two 64-bit integers with 64-bit result.
  149.    Each argument is given as two `int' pieces.
  150.    One argument is L1 and H1; the other, L2 and H2.
  151.    The value is stored as two `int' pieces in *LV and *HV.
  152.    We use the 8-shorts representation internally.  */
  153.  
  154. static void
  155. add_double (l1, h1, l2, h2, lv, hv)
  156.      int l1, h1, l2, h2;
  157.      int *lv, *hv;
  158. {
  159.   short arg1[8];
  160.   short arg2[8];
  161.   register int carry = 0;
  162.   register int i;
  163.  
  164.   encode (arg1, l1, h1);
  165.   encode (arg2, l2, h2);
  166.  
  167.   for (i = 0; i < 8; i++)
  168.     {
  169.       carry += arg1[i] + arg2[i];
  170.       arg1[i] = carry & 0xff;
  171.       carry >>= 8;
  172.     }
  173.  
  174.   decode (arg1, lv, hv);
  175. }
  176.  
  177. /* Negate a 64-bit integers with 64-bit result.
  178.    The argument is given as two `int' pieces in L1 and H1.
  179.    The value is stored as two `int' pieces in *LV and *HV.
  180.    We use the 8-shorts representation internally.  */
  181.  
  182. static void
  183. neg_double (l1, h1, lv, hv)
  184.      int l1, h1;
  185.      int *lv, *hv;
  186. {
  187.   if (l1 == 0)
  188.     {
  189.       *lv = 0;
  190.       *hv = - h1;
  191.     }
  192.   else
  193.     {
  194.       *lv = - l1;
  195.       *hv = ~ h1;
  196.     }
  197. }
  198.  
  199. /* Multiply two 64-bit integers with 64-bit result.
  200.    Each argument is given as two `int' pieces.
  201.    One argument is L1 and H1; the other, L2 and H2.
  202.    The value is stored as two `int' pieces in *LV and *HV.
  203.    We use the 8-shorts representation internally.  */
  204.  
  205. static void
  206. mul_double (l1, h1, l2, h2, lv, hv)
  207.      int l1, h1, l2, h2;
  208.      int *lv, *hv;
  209. {
  210.   short arg1[8];
  211.   short arg2[8];
  212.   short prod[16];
  213.   register int carry = 0;
  214.   register int i, j, k;
  215.  
  216.   /* These two cases are used extensively, arising from pointer
  217.      combinations.  */
  218.   if (h2 == 0)
  219.     {
  220.       if (l2 == 2)
  221.     {
  222.       unsigned temp = l1 + l1;
  223.       *hv = h1 * 2 + (temp < l1);
  224.       *lv = temp;
  225.       return;
  226.     }
  227.       if (l2 == 4)
  228.     {
  229.       unsigned temp = l1 + l1;
  230.       h1 = h1 * 4 + (temp < l1) << 1;
  231.       l1 = temp;
  232.       temp += temp;
  233.       h1 += (temp < l1);
  234.       *lv = temp;
  235.       *hv = h1;
  236.       return;
  237.     }
  238.       if (l2 == 8)
  239.     {
  240.       unsigned temp = l1 + l1;
  241.       h1 = h1 * 8 + (temp < l1) << 2;
  242.       l1 = temp;
  243.       temp += temp;
  244.       h1 += (temp < l1) << 1;
  245.       l1 = temp;
  246.       temp += temp;
  247.       h1 += (temp < l1);
  248.       *lv = temp;
  249.       *hv = h1;
  250.       return;
  251.     }
  252.     }
  253.  
  254.   encode (arg1, l1, h1);
  255.   encode (arg2, l2, h2);
  256.  
  257.   bzero (prod, sizeof prod);
  258.  
  259.   for (i = 0; i < 8; i++)
  260.     for (j = 0; j < 8; j++)
  261.       {
  262.     k = i + j;
  263.     carry = arg1[i] * arg2[j];
  264.     while (carry)
  265.       {
  266.         carry += prod[k];
  267.         prod[k] = carry & 0xff;
  268.         carry >>= 8;
  269.         k++;
  270.       }
  271.       }
  272.  
  273.   decode (prod, lv, hv);    /* @@decode ignores prod[8] -> prod[15] */
  274. }
  275.  
  276. /* Shift the 64-bit integer in L1, H1 left by COUNT places
  277.    keeping only PREC bits of result.
  278.    Shift right if COUNT is negative.
  279.    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  280.    Store the value as two `int' pieces in *LV and *HV.  */
  281.  
  282. static void
  283. lshift_double (l1, h1, count, prec, lv, hv, arith)
  284.      int l1, h1, count, prec;
  285.      int *lv, *hv;
  286.      int arith;
  287. {
  288.   short arg1[8];
  289.   register int i;
  290.   register int carry;
  291.  
  292.   if (count < 0)
  293.     {
  294.       rshift_double (l1, h1, - count, prec, lv, hv, arith);
  295.       return;
  296.     }
  297.  
  298.   encode (arg1, l1, h1);
  299.  
  300.   if (count > prec)
  301.     count = prec;
  302.  
  303.   while (count > 0)
  304.     {
  305.       carry = 0;
  306.       for (i = 0; i < 8; i++)
  307.     {
  308.       carry += arg1[i] << 1;
  309.       arg1[i] = carry & 0xff;
  310.       carry >>= 8;
  311.     }
  312.       count--;
  313.     }
  314.  
  315.   decode (arg1, lv, hv);
  316. }
  317.  
  318. /* Shift the 64-bit integer in L1, H1 right by COUNT places
  319.    keeping only PREC bits of result.  COUNT must be positive.
  320.    ARITH nonzero specifies arithmetic shifting; otherwise use logical shift.
  321.    Store the value as two `int' pieces in *LV and *HV.  */
  322.  
  323. static void
  324. rshift_double (l1, h1, count, prec, lv, hv, arith)
  325.      int l1, h1, count, prec;
  326.      int *lv, *hv;
  327.      int arith;
  328. {
  329.   short arg1[8];
  330.   register int i;
  331.   register int carry;
  332.  
  333.   encode (arg1, l1, h1);
  334.  
  335.   if (count > prec)
  336.     count = prec;
  337.  
  338.   carry = arith && arg1[7] >> 7;
  339.   while (count > 0)
  340.     {
  341.       for (i = 7; i >= 0; i--)
  342.     {
  343.       carry <<= 8;
  344.       carry += arg1[i];
  345.       arg1[i] = (carry >> 1) & 0xff;
  346.     }
  347.       count--;
  348.     }
  349.  
  350.   decode (arg1, lv, hv);
  351. }
  352.  
  353. /* Rotate the 64-bit integer in L1, H1 left by COUNT places
  354.    keeping only PREC bits of result.
  355.    Rotate right if COUNT is negative.
  356.    Store the value as two `int' pieces in *LV and *HV.  */
  357.  
  358. static void
  359. lrotate_double (l1, h1, count, prec, lv, hv)
  360.      int l1, h1, count, prec;
  361.      int *lv, *hv;
  362. {
  363.   short arg1[8];
  364.   register int i;
  365.   register int carry;
  366.  
  367.   if (count < 0)
  368.     {
  369.       rrotate_double (l1, h1, - count, prec, lv, hv);
  370.       return;
  371.     }
  372.  
  373.   encode (arg1, l1, h1);
  374.  
  375.   if (count > prec)
  376.     count = prec;
  377.  
  378.   carry = arg1[7] >> 7;
  379.   while (count > 0)
  380.     {
  381.       for (i = 0; i < 8; i++)
  382.     {
  383.       carry += arg1[i] << 1;
  384.       arg1[i] = carry & 0xff;
  385.       carry >>= 8;
  386.     }
  387.       count--;
  388.     }
  389.  
  390.   decode (arg1, lv, hv);
  391. }
  392.  
  393. /* Rotate the 64-bit integer in L1, H1 left by COUNT places
  394.    keeping only PREC bits of result.  COUNT must be positive.
  395.    Store the value as two `int' pieces in *LV and *HV.  */
  396.  
  397. static void
  398. rrotate_double (l1, h1, count, prec, lv, hv)
  399.      int l1, h1, count, prec;
  400.      int *lv, *hv;
  401. {
  402.   short arg1[8];
  403.   register int i;
  404.   register int carry;
  405.  
  406.   encode (arg1, l1, h1);
  407.  
  408.   if (count > prec)
  409.     count = prec;
  410.  
  411.   carry = arg1[0] & 1;
  412.   while (count > 0)
  413.     {
  414.       for (i = 7; i >= 0; i--)
  415.     {
  416.       carry <<= 8;
  417.       carry += arg1[i];
  418.       arg1[i] = (carry >> 1) & 0xff;
  419.     }
  420.       count--;
  421.     }
  422.  
  423.   decode (arg1, lv, hv);
  424. }
  425.  
  426. /* Divide 64 bit integer LNUM, HNUM by 64 bit integer LDEN, HDEN
  427.    for a quotient (stored in *LQUO, *HQUO) and remainder (in *LREM, *HREM).
  428.    CODE is a tree code for a kind of division, one of
  429.    TRUNC_DIV_EXPR, FLOOR_DIV_EXPR, CEIL_DIV_EXPR, ROUND_DIV_EXPR
  430.    or EXACT_DIV_EXPR
  431.    It controls how the quotient is rounded to a integer.
  432.    UNS nonzero says do unsigned division.  */
  433.  
  434. static void
  435. div_and_round_double (code, uns,
  436.               lnum_orig, hnum_orig, lden_orig, hden_orig,
  437.               lquo, hquo, lrem, hrem)
  438.      enum tree_code code;
  439.      int uns;
  440.      int lnum_orig, hnum_orig;        /* num == numerator == dividend */
  441.      int lden_orig, hden_orig;        /* den == denominator == divisor */
  442.      int *lquo, *hquo, *lrem, *hrem;
  443. {
  444.   int quo_neg = 0;
  445.   short num[9], den[8], quo[8];    /* extra element for scaling.  */
  446.   register int i, j, work;
  447.   register int carry = 0;
  448.   int lnum = lnum_orig, hnum = hnum_orig;
  449.   int lden = lden_orig, hden = hden_orig;
  450.  
  451.   if ((hden == 0) && (lden == 0))
  452.     abort ();
  453.  
  454.   /* calculate quotient sign and convert operands to unsigned.  */
  455.   if (!uns) 
  456.     {
  457.       if (hden < 0) 
  458.     {
  459.       quo_neg = ~ quo_neg;
  460.       neg_double (lden, hden, &lden, &hden);
  461.     }
  462.       if (hnum < 0)
  463.     {
  464.       quo_neg = ~ quo_neg;
  465.       neg_double (lnum, hnum, &lnum, &hnum);
  466.     }
  467.     }
  468.  
  469.   if (hnum == 0 && hden == 0)
  470.     {                /* single precision */
  471.       *hquo = *hrem = 0;
  472.       *lquo = (unsigned) lnum / lden;    /* rounds toward zero since positive args */
  473.       goto finish_up;
  474.     }
  475.  
  476.   if (hnum == 0)
  477.     {                /* trivial case: dividend < divisor */
  478.       /* hden != 0 already checked.  */
  479.       *hquo = *lquo = 0;
  480.       *hrem = hnum;
  481.       *lrem = lnum;
  482.       goto finish_up;
  483.     }
  484.  
  485.   bzero (quo, sizeof quo);
  486.  
  487.   bzero (num, sizeof num);    /* to zero 9th element */
  488.   bzero (den, sizeof den);
  489.  
  490.   encode (num, lnum, hnum); 
  491.   encode (den, lden, hden);
  492.  
  493.   if (hden == 0)
  494.     {                /* simpler algorithm */
  495.       /* hnum != 0 already checked.  */
  496.       for (i = 7; i >= 0; i--)
  497.     {
  498.       work = num[i] + (carry << 8);
  499.       quo[i] = work / lden;
  500.       carry = work % lden;
  501.     }
  502.     }
  503.   else {            /* full double precision,
  504.                    with thanks to Don Knuth's
  505.                    "Semi-Numericial Algorithms".  */
  506. #define BASE 256
  507.     int quo_est, scale, num_hi_sig, den_hi_sig, quo_hi_sig;
  508.  
  509.     /* Find the highest non-zero divisor digit.  */
  510.     for (i = 7; ; i--)
  511.       if (den[i] != 0) {
  512.     den_hi_sig = i;
  513.     break;
  514.       }
  515.     for (i = 7; ; i--)
  516.       if (num[i] != 0) {
  517.     num_hi_sig = i;
  518.     break;
  519.       }
  520.     quo_hi_sig = num_hi_sig - den_hi_sig + 1;
  521.  
  522.     /* Insure that the first digit of the divisor is at least BASE/2.
  523.        This is required by the quotient digit estimation algorithm.  */
  524.  
  525.     scale = BASE / (den[den_hi_sig] + 1);
  526.     if (scale > 1) {        /* scale divisor and dividend */
  527.       carry = 0;
  528.       for (i = 0; i <= 8; i++) {
  529.     work = (num[i] * scale) + carry;
  530.     num[i] = work & 0xff;
  531.     carry = work >> 8;
  532.     if (num[i] != 0) num_hi_sig = i;
  533.       }
  534.       carry = 0;
  535.       for (i = 0; i <= 7; i++) {
  536.     work = (den[i] * scale) + carry;
  537.     den[i] = work & 0xff;
  538.     carry = work >> 8;
  539.     if (den[i] != 0) den_hi_sig = i;
  540.       }
  541.     }
  542.  
  543.     /* Main loop */
  544.     for (i = quo_hi_sig; i > 0; i--) {
  545.       /* quess the next quotient digit, quo_est, by dividing the first
  546.      two remaining dividend digits by the high order quotient digit.
  547.      quo_est is never low and is at most 2 high.  */
  548.  
  549.       int num_hi;        /* index of highest remaining dividend digit */
  550.  
  551.       num_hi = i + den_hi_sig;
  552.  
  553.       work = (num[num_hi] * BASE) + (num_hi ? 0 : num[num_hi - 1]);
  554.       if (num[num_hi] != den[den_hi_sig]) {
  555.     quo_est = work / den[den_hi_sig];
  556.       }
  557.       else {
  558.     quo_est = BASE - 1;
  559.       }
  560.  
  561.       /* refine quo_est so it's usually correct, and at most one high.   */
  562.       while ((den[den_hi_sig - 1] * quo_est)
  563.          > (((work - (quo_est * den[den_hi_sig])) * BASE)
  564.          + ((num_hi - 1) ? 0 : num[num_hi - 2]))) {
  565.     quo_est--;
  566.       }
  567.  
  568.       /* try quo_est as the quotient digit, by multiplying the
  569.          divisor by quo_est and subtracting from the remaining dividend.  */
  570.  
  571.       carry = 0;
  572.  
  573.       for (j = 0; j <= den_hi_sig; j++) {
  574.     int digit;
  575.  
  576.     work = num[i + j] - (quo_est * den[j]) + carry;
  577.     digit = work & 0xff;
  578.     carry = work >> 8;
  579.     if (digit < 0) {
  580.       digit += BASE;
  581.       carry--;
  582.     }
  583.     num[i + j] = digit;
  584.       }
  585.  
  586.       /* if quo_est was high by one, then num[i] went negative and
  587.      we need to correct things.  */
  588.  
  589.       if (num[num_hi] < 0) {
  590.     quo_est--;
  591.     carry = 0;        /* add divisor back in */
  592.     for (j = 0; j <= den_hi_sig; j++) {
  593.       work = num[i + j] + den[j] + carry;
  594.       if (work > BASE) {
  595.         work -= BASE;
  596.         carry = 1;
  597.       }
  598.       else {
  599.         carry = 0;
  600.       }
  601.       num[i + j] = work;
  602.     }
  603.     num [num_hi] += carry;
  604.       }
  605.  
  606.       /* store the quotient digit.  */
  607.       quo[i - 1] = quo_est;
  608.     }
  609.   }
  610.  
  611.   decode (quo, lquo, hquo);
  612.  
  613.  finish_up:
  614.   /* if result is negative, make it so.  */
  615.   if (quo_neg)
  616.     neg_double (*lquo, *hquo, lquo, hquo);
  617.  
  618.   /* compute trial remainder:  rem = num - (quo * den)  */
  619.   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
  620.   neg_double (*lrem, *hrem, lrem, hrem);
  621.   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
  622.  
  623.   switch (code)
  624.     {
  625.     case TRUNC_DIV_EXPR:
  626.     case TRUNC_MOD_EXPR:    /* round toward zero */
  627.     case EXACT_DIV_EXPR:    /* for this one, it shouldn't matter */
  628.       return;
  629.  
  630.     case FLOOR_DIV_EXPR:
  631.     case FLOOR_MOD_EXPR:    /* round toward negative infinity */
  632.       if (quo_neg && (*lrem != 0 || *hrem != 0))   /* ratio < 0 && rem != 0 */
  633.     {
  634.       /* quo = quo - 1;  */
  635.       add_double (*lquo, *hquo, -1, -1, lquo, hquo);
  636.     }
  637.       else return;
  638.       break;
  639.  
  640.     case CEIL_DIV_EXPR:
  641.     case CEIL_MOD_EXPR:        /* round toward positive infinity */
  642.       if (!quo_neg && (*lrem != 0 || *hrem != 0))  /* ratio > 0 && rem != 0 */
  643.     {
  644.       add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  645.     }
  646.       else return;
  647.       break;
  648.     
  649.     case ROUND_DIV_EXPR:
  650.     case ROUND_MOD_EXPR:    /* round to closest integer */
  651.       {
  652.     int labs_rem = *lrem, habs_rem = *hrem;
  653.     int labs_den = lden, habs_den = hden, ltwice, htwice;
  654.  
  655.     /* get absolute values */
  656.     if (*hrem < 0) neg_double (*lrem, *hrem, &labs_rem, &habs_rem);
  657.     if (hden < 0) neg_double (lden, hden, &labs_den, &habs_den);
  658.  
  659.     /* if (2 * abs (lrem) >= abs (lden)) */
  660.     mul_double (2, 0, labs_rem, habs_rem, <wice, &htwice);
  661.     if (((unsigned) habs_den < (unsigned) htwice)
  662.         || (((unsigned) habs_den == (unsigned) htwice)
  663.         && ((unsigned) labs_den < (unsigned) ltwice)))
  664.       {
  665.         if (*hquo < 0)
  666.           /* quo = quo - 1;  */
  667.           add_double (*lquo, *hquo, -1, -1, lquo, hquo);
  668.         else
  669.           /* quo = quo + 1; */
  670.           add_double (*lquo, *hquo, 1, 0, lquo, hquo);
  671.       }
  672.     else return;
  673.       }
  674.       break;
  675.  
  676.     default:
  677.       abort ();
  678.     }
  679.  
  680.   /* compute true remainder:  rem = num - (quo * den)  */
  681.   mul_double (*lquo, *hquo, lden_orig, hden_orig, lrem, hrem);
  682.   neg_double (*lrem, *hrem, lrem, hrem);
  683.   add_double (lnum_orig, hnum_orig, *lrem, *hrem, lrem, hrem);
  684. }
  685.  
  686. /* Split a tree IN into a constant and a variable part
  687.    that could be combined with CODE to make IN.
  688.    CODE must be a commutative arithmetic operation.
  689.    Store the constant part into *CONP and the variable in &VARP.
  690.    Return 1 if this was done; zero means the tree IN did not decompose
  691.    this way.
  692.  
  693.    If CODE is PLUS_EXPR we also split trees that use MINUS_EXPR.
  694.    Therefore, we must tell the caller whether the variable part
  695.    was subtracted.  We do this by storing 1 or -1 into *VARSIGNP.
  696.    The value stored is the coefficient for the variable term.
  697.    The constant term we return should always be added;
  698.    we negate it if necessary.  */
  699.  
  700. static int
  701. split_tree (in, code, varp, conp, varsignp)
  702.      tree in;
  703.      enum tree_code code;
  704.      tree *varp, *conp;
  705.      int *varsignp;
  706. {
  707.   register tree outtype = TREE_TYPE (in);
  708.   *varp = 0;
  709.   *conp = 0;
  710.  
  711.   /* Strip any conversions that don't change the machine mode.  */
  712.   while ((TREE_CODE (in) == NOP_EXPR
  713.       || TREE_CODE (in) == CONVERT_EXPR)
  714.      && (TYPE_MODE (TREE_TYPE (in))
  715.          == TYPE_MODE (TREE_TYPE (TREE_OPERAND (in, 0)))))
  716.     in = TREE_OPERAND (in, 0);
  717.  
  718.   if (TREE_CODE (in) == code
  719.       || (TREE_CODE (TREE_TYPE (in)) != REAL_TYPE
  720.       /* We can associate addition and subtraction together
  721.          (even though the C standard doesn't say so)
  722.          for integers because the value is not affected.
  723.          For reals, the value might be affected, so we can't.  */
  724.       &&
  725.       ((code == PLUS_EXPR && TREE_CODE (in) == MINUS_EXPR)
  726.        || (code == MINUS_EXPR && TREE_CODE (in) == PLUS_EXPR))))
  727.     {
  728.       enum tree_code code = TREE_CODE (TREE_OPERAND (in, 0));
  729.       if (code == INTEGER_CST)
  730.     {
  731.       *conp = TREE_OPERAND (in, 0);
  732.       *varp = TREE_OPERAND (in, 1);
  733.       if (TREE_TYPE (*varp) != outtype)
  734.         *varp = convert (outtype, *varp);
  735.       *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
  736.       return 1;
  737.     }
  738.       if (TREE_LITERAL (TREE_OPERAND (in, 1)))
  739.     {
  740.       *conp = TREE_OPERAND (in, 1);
  741.       *varp = TREE_OPERAND (in, 0);
  742.       *varsignp = 1;
  743.       if (TREE_TYPE (*varp) != outtype)
  744.         *varp = convert (outtype, *varp);
  745.       if (TREE_CODE (in) == MINUS_EXPR)
  746.         {
  747.           /* If operation is subtraction and constant is second,
  748.          must negate it to get an additive constant.
  749.          And this cannot be done unless it is a manifest constant.
  750.          It could also be the address of a static variable.
  751.          We cannot negate that, so give up.  */
  752.           if (TREE_CODE (*conp) == INTEGER_CST)
  753.         *conp = combine (MINUS_EXPR, integer_zero_node, *conp);
  754.           else
  755.         return 0;
  756.         }
  757.       return 1;
  758.     }
  759.       if (TREE_LITERAL (TREE_OPERAND (in, 0)))
  760.     {
  761.       *conp = TREE_OPERAND (in, 0);
  762.       *varp = TREE_OPERAND (in, 1);
  763.       if (TREE_TYPE (*varp) != outtype)
  764.         *varp = convert (outtype, *varp);
  765.       *varsignp = (TREE_CODE (in) == MINUS_EXPR) ? -1 : 1;
  766.       return 1;
  767.     }
  768.     }
  769.   return 0;
  770. }
  771.  
  772. /* Combine two constants NUM and ARG2 under operation CODE
  773.    to produce a new constant.
  774.    We assume ARG1 and ARG2 have the same data type,
  775.    or at least are the same kind of constant and the same machine mode.  */
  776.  
  777. /* Handle floating overflow for `combine'.  */
  778. static jmp_buf combine_error;
  779.  
  780. tree
  781. combine (code, arg1, arg2)
  782.      enum tree_code code;
  783.      register tree arg1, arg2;
  784. {
  785.   if (TREE_CODE (arg1) == INTEGER_CST)
  786.     {
  787.       register int int1l = TREE_INT_CST_LOW (arg1);
  788.       register int int1h = TREE_INT_CST_HIGH (arg1);
  789.       int int2l = TREE_INT_CST_LOW (arg2);
  790.       int int2h = TREE_INT_CST_HIGH (arg2);
  791.       int low, hi;
  792.       int garbagel, garbageh;
  793.       register tree t;
  794.       int uns = TREE_UNSIGNED (TREE_TYPE (arg1));
  795.  
  796.       switch (code)
  797.     {
  798.     case BIT_IOR_EXPR:
  799.       t = build_int_2 (int1l | int2l, int1h | int2h);
  800.       break;
  801.  
  802.     case BIT_XOR_EXPR:
  803.       t = build_int_2 (int1l ^ int2l, int1h ^ int2h);
  804.       break;
  805.  
  806.     case BIT_AND_EXPR:
  807.       t = build_int_2 (int1l & int2l, int1h & int2h);
  808.       break;
  809.  
  810.     case BIT_ANDTC_EXPR:
  811.       t = build_int_2 (int1l & ~int2l, int1h & ~int2h);
  812.       break;
  813.  
  814.     case RSHIFT_EXPR:
  815.       int2l = - int2l;
  816.     case LSHIFT_EXPR:
  817.       lshift_double (int1l, int1h, int2l,
  818.              TYPE_PRECISION (TREE_TYPE (arg1)),
  819.              &low, &hi,
  820.              !uns);
  821.       t = build_int_2 (low, hi);
  822.       break;
  823.  
  824.     case RROTATE_EXPR:
  825.       int2l = - int2l;
  826.     case LROTATE_EXPR:
  827.       lrotate_double (int1l, int1h, int2l,
  828.               TYPE_PRECISION (TREE_TYPE (arg1)),
  829.               &low, &hi);
  830.       t = build_int_2 (low, hi);
  831.       break;
  832.  
  833.     case PLUS_EXPR:
  834.       if (int1h == 0)
  835.         {
  836.           int2l += int1l;
  837.           if ((unsigned) int2l < int1l)
  838.         int2h += 1;
  839.           t = build_int_2 (int2l, int2h);
  840.           break;
  841.         }
  842.       if (int2h == 0)
  843.         {
  844.           int1l += int2l;
  845.           if ((unsigned) int1l < int2l)
  846.         int1h += 1;
  847.           t = build_int_2 (int1l, int1h);
  848.           break;
  849.         }
  850.       add_double (int1l, int1h, int2l, int2h, &low, &hi);
  851.       t = build_int_2 (low, hi);
  852.       break;
  853.  
  854.     case MINUS_EXPR:
  855.       if (int1h == 0 && int1l == 0)
  856.         {
  857.           t = build_int_2 (- int2l, - int2h - (int2l != 0));
  858.           break;
  859.         }
  860.       if (int2h == 0 && int2l == 0)
  861.         {
  862.           t = build_int_2 (int1l, int1h);
  863.           break;
  864.         }
  865.       neg_double (int2l, int2h, &int2l, &int2h);
  866.       add_double (int1l, int1h, int2l, int2h, &low, &hi);
  867.       t = build_int_2 (low, hi);
  868.       break;
  869.  
  870.     case MULT_EXPR:
  871.   /* Optimize simple cases.  */
  872.       if (int1h == 0)
  873.         {
  874.           unsigned temp;
  875.  
  876.           switch (int1l)
  877.         {
  878.         case 0:
  879.           t = build_int_2 (0, 0);
  880.           goto got_it;
  881.         case 1:
  882.           t = build_int_2 (int2l, int2h);
  883.           goto got_it;
  884.         case 2:
  885.           temp = int2l + int2l;
  886.           int2h = int2h * 2 + (temp < int2l);
  887.           t = build_int_2 (temp, int2h);
  888.           goto got_it;
  889.         case 3:
  890.           temp = int2l + int2l + int2l;
  891.           int2h = int2h * 3 + (temp < int2l);
  892.           t = build_int_2 (temp, int2h);
  893.           goto got_it;
  894.         case 4:
  895.           temp = int2l + int2l;
  896.           int2h = int2h * 4 + (temp < int2l) << 1;
  897.           int2l = temp;
  898.           temp += temp;
  899.           int2h += (temp < int2l);
  900.           t = build_int_2 (temp, int2h);
  901.           goto got_it;
  902.         case 8:
  903.           temp = int2l + int2l;
  904.           int2h = int2h * 8 + (temp < int2l) << 2;
  905.           int2l = temp;
  906.           temp += temp;
  907.           int2h += (temp < int2l) << 1;
  908.           int2l = temp;
  909.           temp += temp;
  910.           int2h += (temp < int2l);
  911.           t = build_int_2 (temp, int2h);
  912.           goto got_it;
  913.         default:
  914.           break;
  915.         }
  916.         }
  917.  
  918.       if (int2h == 0)
  919.         {
  920.           if (int2l == 0)
  921.         {
  922.           t = build_int_2 (0, 0);
  923.           break;
  924.         }
  925.           if (int2l == 1)
  926.         {
  927.           t = build_int_2 (int1l, int1h);
  928.           break;
  929.         }
  930.         }
  931.  
  932.       mul_double (int1l, int1h, int2l, int2h, &low, &hi);
  933.       t = build_int_2 (low, hi);
  934.       break;
  935.  
  936.     case TRUNC_DIV_EXPR: case ROUND_DIV_EXPR: 
  937.     case FLOOR_DIV_EXPR: case CEIL_DIV_EXPR:
  938.     case EXACT_DIV_EXPR:
  939.       if (int2h == 0 && int2l == 1)
  940.         {
  941.           t = build_int_2 (int1l, int1h);
  942.           break;
  943.         }
  944.       if (int1l == int2l && int1h == int2h)
  945.         {
  946.           if ((int1l | int1h) == 0)
  947.         abort ();
  948.           t = build_int_2 (1, 0);
  949.           break;
  950.         }
  951.       div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
  952.                 &low, &hi, &garbagel, &garbageh);
  953.       t = build_int_2 (low, hi);
  954.       break;
  955.  
  956.     case TRUNC_MOD_EXPR: case ROUND_MOD_EXPR: 
  957.     case FLOOR_MOD_EXPR: case CEIL_MOD_EXPR:
  958.       div_and_round_double (code, uns, int1l, int1h, int2l, int2h,
  959.                 &garbagel, &garbageh, &low, &hi);
  960.       t = build_int_2 (low, hi);
  961.       break;
  962.  
  963.     case MIN_EXPR:
  964.     case MAX_EXPR:
  965.       if (uns)
  966.         {
  967.           low = (((unsigned) int1h < (unsigned) int2h)
  968.              || (((unsigned) int1h == (unsigned) int2h)
  969.              && ((unsigned) int1l < (unsigned) int2l)));
  970.         }
  971.       else
  972.         {
  973.           low = ((int1h < int2h)
  974.              || ((int1h == int2h)
  975.              && ((unsigned) int1l < (unsigned) int2l)));
  976.         }
  977.       if (low == (code == MIN_EXPR))
  978.         t = build_int_2 (int1l, int1h);
  979.       else
  980.         t = build_int_2 (int2l, int2h);
  981.       break;
  982.  
  983.     default:
  984.       abort ();
  985.     }
  986.     got_it:
  987.       TREE_TYPE (t) = TREE_TYPE (arg1);
  988.       force_fit_type (t);
  989.       return t;
  990.     }
  991. #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  992.   if (TREE_CODE (arg1) == REAL_CST)
  993.     {
  994.       register REAL_VALUE_TYPE d1 = TREE_REAL_CST (arg1);
  995.       register REAL_VALUE_TYPE d2 = TREE_REAL_CST (arg2);
  996.       register REAL_VALUE_TYPE value;
  997.  
  998.       if (setjmp (combine_error))
  999.     {
  1000.       warning ("floating overflow in constant folding");
  1001.       return build (code, TREE_TYPE (arg1), arg1, arg2);
  1002.     }
  1003.       set_float_handler (combine_error);
  1004.  
  1005. #ifdef REAL_ARITHMETIC
  1006.       REAL_ARITHMETIC (value, code, d1, d2);
  1007. #else
  1008.       switch (code)
  1009.     {
  1010.     case PLUS_EXPR:
  1011.       value = d1 + d2;
  1012.       break;
  1013.  
  1014.     case MINUS_EXPR:
  1015.       value = d1 - d2;
  1016.       break;
  1017.  
  1018.     case MULT_EXPR:
  1019.       value = d1 * d2;
  1020.       break;
  1021.  
  1022.     case RDIV_EXPR:
  1023.       if (d2 == 0)
  1024.         abort ();
  1025.  
  1026.       value = d1 / d2;
  1027.       break;
  1028.  
  1029.     case MIN_EXPR:
  1030.       value = d1 < d2 ? d1 : d2;
  1031.       break;
  1032.  
  1033.     case MAX_EXPR:
  1034.       value = d1 > d2 ? d1 : d2;
  1035.       break;
  1036.  
  1037.     default:
  1038.       abort ();
  1039.     }
  1040. #endif /* no REAL_ARITHMETIC */
  1041.       set_float_handler (0);
  1042.       return build_real (TREE_TYPE (arg1), value);
  1043.     }
  1044. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1045.   if (TREE_CODE (arg1) == COMPLEX_CST)
  1046.     {
  1047.       register tree r1 = TREE_REALPART (arg1);
  1048.       register tree i1 = TREE_IMAGPART (arg1);
  1049.       register tree r2 = TREE_REALPART (arg2);
  1050.       register tree i2 = TREE_IMAGPART (arg2);
  1051.       register tree t;
  1052.  
  1053.       switch (code)
  1054.     {
  1055.     case PLUS_EXPR:
  1056.       t = build_complex (combine (PLUS_EXPR, r1, r2),
  1057.                  combine (PLUS_EXPR, i1, i2));
  1058.       break;
  1059.  
  1060.     case MINUS_EXPR:
  1061.       t = build_complex (combine (MINUS_EXPR, r1, r2),
  1062.                  combine (MINUS_EXPR, i1, i2));
  1063.       break;
  1064.  
  1065.     case MULT_EXPR:
  1066.       t = build_complex (combine (MINUS_EXPR,
  1067.                       combine (MULT_EXPR, r1, r2),
  1068.                       combine (MULT_EXPR, i1, i2)),
  1069.                  combine (PLUS_EXPR,
  1070.                       combine (MULT_EXPR, r1, i2),
  1071.                       combine (MULT_EXPR, i1, r2)));
  1072.       break;
  1073.  
  1074.     case RDIV_EXPR:
  1075.       {
  1076.         register tree magsquared
  1077.           = combine (PLUS_EXPR,
  1078.              combine (MULT_EXPR, r2, r2),
  1079.              combine (MULT_EXPR, i2, i2));
  1080.         t = build_complex (combine (RDIV_EXPR,
  1081.                     combine (PLUS_EXPR,
  1082.                          combine (MULT_EXPR, r1, r2),
  1083.                          combine (MULT_EXPR, i1, i2)),
  1084.                     magsquared),
  1085.                    combine (RDIV_EXPR,
  1086.                     combine (MINUS_EXPR,
  1087.                          combine (MULT_EXPR, i1, r2),
  1088.                          combine (MULT_EXPR, r1, i2)),
  1089.                     magsquared));
  1090.       }
  1091.       break;
  1092.  
  1093.     default:
  1094.       abort ();
  1095.     }
  1096.       TREE_TYPE (t) = TREE_TYPE (arg1);
  1097.       return t;
  1098.     }
  1099.   return 0;
  1100. }
  1101.  
  1102. /* Given T, a tree representing type conversion of a constant,
  1103.    return a constant tree representing the result of conversion.  */
  1104.  
  1105. static tree
  1106. fold_convert (t)
  1107.      register tree t;
  1108. {
  1109.   register tree arg1 = TREE_OPERAND (t, 0);
  1110.   register tree type = TREE_TYPE (t);
  1111.  
  1112. #if defined( DSP56000 )
  1113.   /* don't blow off casts from ints to pointers when pointers aren't the same
  1114.      size as ints. */
  1115.   if (TREE_CODE (type) == INTEGER_TYPE
  1116. #else
  1117.   if (TREE_CODE (type) == POINTER_TYPE
  1118.       || TREE_CODE (type) == INTEGER_TYPE
  1119. #endif
  1120.       || TREE_CODE (type) == ENUMERAL_TYPE)
  1121.     {
  1122.       if (TREE_CODE (arg1) == INTEGER_CST)
  1123.     {
  1124.       /* Given an integer constant, make new constant with new type,
  1125.          appropriately sign-extended or truncated.  */
  1126.       t = build_int_2 (TREE_INT_CST_LOW (arg1),
  1127.                TREE_INT_CST_HIGH (arg1));
  1128.       TREE_TYPE (t) = type;
  1129.       force_fit_type (t);
  1130.     }
  1131. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  1132.       else if (TREE_CODE (arg1) == REAL_CST)
  1133.     {
  1134.       if (REAL_VALUES_LESS (real_value_from_int_cst (TYPE_MAX_VALUE (type)),
  1135.                 TREE_REAL_CST (arg1))
  1136.           || REAL_VALUES_LESS (TREE_REAL_CST (arg1),
  1137.                    real_value_from_int_cst (TYPE_MIN_VALUE (type))))
  1138.         {
  1139.           warning ("real constant out of range for integer conversion");
  1140.           return t;
  1141.         }
  1142. #ifndef REAL_ARITHMETIC
  1143.       {
  1144.         REAL_VALUE_TYPE d;
  1145.         int low, high;
  1146.         int half_word = 1 << (HOST_BITS_PER_INT / 2);
  1147.  
  1148.         d = TREE_REAL_CST (arg1);
  1149.         if (d < 0)
  1150.           d = -d;
  1151.  
  1152.         high = (int) (d / half_word / half_word);
  1153.         d -= (REAL_VALUE_TYPE) high * half_word * half_word;
  1154.         low = (unsigned) d;
  1155.         if (TREE_REAL_CST (arg1) < 0)
  1156.           neg_double (low, high, &low, &high);
  1157.         t = build_int_2 (low, high);
  1158.       }
  1159. #else
  1160.       {
  1161.         int low, high;
  1162.         REAL_VALUE_TO_INT (low, high, TREE_REAL_CST (arg1));
  1163.         t = build_int_2 (low, high);
  1164.       }
  1165. #endif
  1166.       TREE_TYPE (t) = type;
  1167.       force_fit_type (t);
  1168.     }
  1169. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1170.       TREE_TYPE (t) = type;
  1171.     }
  1172.   else if (TREE_CODE (type) == REAL_TYPE)
  1173.     {
  1174. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  1175.       if (TREE_CODE (arg1) == INTEGER_CST)
  1176.     return build_real_from_int_cst (type, arg1);
  1177. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1178.       if (TREE_CODE (arg1) == REAL_CST)
  1179.     return build_real (type, TREE_REAL_CST (arg1));
  1180.     }
  1181.   TREE_LITERAL (t) = 1;
  1182.   return t;
  1183. }
  1184.  
  1185. /* Return nonzero if two constants (that are not manifest constants)
  1186.    are necessarily equal.  It detects only the easiest, common case of
  1187.    equality.  */
  1188.  
  1189. static int
  1190. operand_equal_p (arg0, arg1)
  1191.      tree arg0, arg1;
  1192. {
  1193.   while ((TREE_CODE (arg0) == NOP_EXPR
  1194.       || TREE_CODE (arg0) == CONVERT_EXPR)
  1195.      && TYPE_MODE (TREE_TYPE (arg0)) == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg0, 0))))
  1196.     arg0 = TREE_OPERAND (arg0, 0);
  1197.   while ((TREE_CODE (arg1) == NOP_EXPR
  1198.       || TREE_CODE (arg1) == CONVERT_EXPR)
  1199.      && TYPE_MODE (TREE_TYPE (arg1)) == TYPE_MODE (TREE_TYPE (TREE_OPERAND (arg1, 0))))
  1200.     arg1 = TREE_OPERAND (arg1, 0);
  1201.  
  1202.   if (TREE_CODE (arg0) == TREE_CODE (arg1)
  1203.       && TREE_CODE (arg0) == ADDR_EXPR
  1204.       && TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0))
  1205.     return 1;
  1206.   return 0;
  1207. }
  1208.  
  1209. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  1210.  
  1211. /* Return 1 if ARG is a real constant with value zero.
  1212.    This function is not defined in the case where it is impossible
  1213.    to tell whether a real constant is zero (for cross-compilation).  */
  1214.  
  1215. static int
  1216. real_zerop (arg)
  1217.      tree arg;
  1218. {
  1219. #ifdef REAL_IS_NOT_DOUBLE
  1220.   tree t1 = build_real_from_int_cst (TREE_TYPE (arg), integer_zero_node);
  1221.   return REAL_VALUES_EQUAL (TREE_REAL_CST (arg), TREE_REAL_CST (t1));
  1222. #else
  1223.   return TREE_REAL_CST (arg) == 0;
  1224. #endif
  1225. }
  1226. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1227.  
  1228. /* Perform constant folding and related simplification of EXPR.
  1229.    The related simplifications include x*1 => x, x*0 => 0, etc.,
  1230.    and application of the associative law.
  1231.    NOP_EXPR conversions may be removed freely (as long as we
  1232.    are careful not to change the C type of the overall expression)
  1233.    We cannot simplify through a CONVERT_EXPR, FIX_EXPR or FLOAT_EXPR,
  1234.    but we can constant-fold them if they have constant operands.  */
  1235.  
  1236. tree
  1237. fold (expr) 
  1238.      tree expr;
  1239. {
  1240.   register tree t = expr;
  1241.   tree type = TREE_TYPE (expr);
  1242.   register tree arg0, arg1;
  1243.   register enum tree_code code = TREE_CODE (t);
  1244.   register int kind;
  1245.  
  1246.   /* WINS will be nonzero when the switch is done
  1247.      if all operands are constant.
  1248.  
  1249.      LOSES will be nonzero when the switch is done
  1250.      if any operand is volatile.
  1251.      This inhibits optimizations such as  (foo () * 0) => 0.
  1252.      But identity-element optimizations such as
  1253.      (foo () * 1) => (foo ()) can be done even if LOSES is set.  */
  1254.  
  1255.   int wins = 1;
  1256.   int loses = 0;
  1257.  
  1258.   /* Return right away if already constant.  */
  1259.   if (TREE_LITERAL (t))
  1260.     {
  1261.       if (code == CONST_DECL)
  1262.     return DECL_INITIAL (t);
  1263.       return t;
  1264.     }
  1265.   
  1266.   kind = *tree_code_type[(int) code];
  1267.   if (kind == 'e' || kind == 'r')
  1268.     {
  1269.       register int len = tree_code_length[(int) code];
  1270.       register int i;
  1271.       for (i = 0; i < len; i++)
  1272.     {
  1273.       if (TREE_OPERAND (t, i) == 0)
  1274.         continue;        /* Valid for CALL_EXPR, at least.  */
  1275.       if (TREE_CODE (TREE_OPERAND (t, i)) != INTEGER_CST
  1276. #if ! defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  1277.           && TREE_CODE (TREE_OPERAND (t, i)) != REAL_CST
  1278. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1279.           )
  1280.         /* Note that TREE_LITERAL isn't enough:
  1281.            static var addresses are constant but we can't
  1282.            do arithmetic on them.  */
  1283.         wins = 0;
  1284.       if (TREE_VOLATILE (TREE_OPERAND (t, i)))
  1285.         loses = 1;
  1286.     }
  1287.       arg0 = TREE_OPERAND (t, 0);
  1288.       if (len > 1)
  1289.     arg1 = TREE_OPERAND (t, 1);
  1290.     }
  1291.  
  1292.   /* Now WINS and LOSES are set as described above,
  1293.      ARG0 is the first operand of EXPR,
  1294.      and ARG1 is the second operand (if it has more than one operand).  */
  1295.  
  1296.   switch (code)
  1297.     {
  1298.     case INTEGER_CST:
  1299.     case REAL_CST:
  1300.     case STRING_CST:
  1301.     case COMPLEX_CST:
  1302.     case CONSTRUCTOR:
  1303.       return t;
  1304.  
  1305.     case CONST_DECL:
  1306.       return fold (DECL_INITIAL (t));
  1307.  
  1308.     case NOP_EXPR:
  1309.     case FLOAT_EXPR:
  1310.     case CONVERT_EXPR:
  1311.     case FIX_TRUNC_EXPR:
  1312.       /* Other kinds of FIX are not handled properly by fold_convert.  */
  1313.       if (!wins)
  1314.     {
  1315.       TREE_LITERAL (t) = TREE_LITERAL (arg0);
  1316.       return t;
  1317.     }
  1318.       return fold_convert (t);
  1319.  
  1320. #if 0  /* This loses on &"foo"[0].  */
  1321.     case ARRAY_REF:
  1322.     {
  1323.       int i;
  1324.  
  1325.       /* Fold an expression like: "foo"[2] */
  1326.       if (TREE_CODE (arg0) == STRING_CST
  1327.           && TREE_CODE (arg1) == INTEGER_CST
  1328.           && !TREE_INT_CST_HIGH (arg1)
  1329.           && (i = TREE_INT_CST_LOW (arg1)) < TREE_STRING_LENGTH (arg0))
  1330.         {
  1331.           t = build_int_2 (TREE_STRING_POINTER (arg0)[i], 0);
  1332.           TREE_TYPE (t) = TREE_TYPE (TREE_TYPE (arg0));
  1333.           force_fit_type (t);
  1334.         }
  1335.     }
  1336.       return t;
  1337. #endif /* 0 */
  1338.  
  1339.     case RANGE_EXPR:
  1340.       TREE_LITERAL (t) = wins;
  1341.       return t;
  1342.  
  1343.     case NEGATE_EXPR:
  1344.       if (wins)
  1345.     {
  1346.       if (TREE_CODE (arg0) == INTEGER_CST)
  1347.         {
  1348.           if (TREE_INT_CST_LOW (arg0) == 0)
  1349.         t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
  1350.           else
  1351.         t = build_int_2 (- TREE_INT_CST_LOW (arg0),
  1352.                  ~ TREE_INT_CST_HIGH (arg0));
  1353.           TREE_TYPE (t) = type;
  1354.           force_fit_type (t);
  1355.         }
  1356.       else if (TREE_CODE (arg0) == REAL_CST)
  1357.         t = build_real (type, REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
  1358.       TREE_TYPE (t) = type;
  1359.     }
  1360.       return t;
  1361.  
  1362.     case ABS_EXPR:
  1363.       if (wins)
  1364.     {
  1365.       if (TREE_CODE (arg0) == INTEGER_CST)
  1366.         {
  1367.           if (! TREE_UNSIGNED (type)
  1368.           && TREE_INT_CST_HIGH (arg0) < 0)
  1369.         {
  1370.           if (TREE_INT_CST_LOW (arg0) == 0)
  1371.             t = build_int_2 (0, - TREE_INT_CST_HIGH (arg0));
  1372.           else
  1373.             t = build_int_2 (- TREE_INT_CST_LOW (arg0),
  1374.                      ~ TREE_INT_CST_HIGH (arg0));
  1375.         }
  1376.         }
  1377.       else if (TREE_CODE (arg0) == REAL_CST)
  1378.         {
  1379.           if (
  1380. #if defined (REAL_IS_NOT_DOUBLE)
  1381.           REAL_VALUES_LESS (TREE_REAL_CST (arg0),
  1382.                     REAL_VALUE_ATOF ("0.0"))
  1383. #else
  1384.           REAL_VALUES_LESS (TREE_REAL_CST (arg0), 0)
  1385. #endif
  1386.           )
  1387.         t = build_real (type,
  1388.                 REAL_VALUE_NEGATE (TREE_REAL_CST (arg0)));
  1389.         }
  1390.       TREE_TYPE (t) = type;
  1391.     }
  1392.       return t;
  1393.  
  1394.     case BIT_NOT_EXPR:
  1395.       if (wins)
  1396.     {
  1397.       if (TREE_CODE (arg0) == INTEGER_CST)
  1398.         t = build_int_2 (~ TREE_INT_CST_LOW (arg0),
  1399.                  ~ TREE_INT_CST_HIGH (arg0));
  1400.       TREE_TYPE (t) = type;
  1401.       force_fit_type (t);
  1402.     }
  1403.       return t;
  1404.  
  1405.     case PLUS_EXPR:
  1406.       if (integer_zerop (arg0))
  1407.     return convert (type, arg1);
  1408.       if (integer_zerop (arg1))
  1409.     return convert (type, arg0);
  1410.     associate:
  1411.       /* In most languages, can't associate operations on floats
  1412.      through parentheses.  Rather than remember where the parentheses
  1413.      were, we don't associate floats at all.  It shouldn't matter much.  */
  1414.       if (TREE_CODE (type) == REAL_TYPE)
  1415.     goto binary;
  1416.       /* The varsign == -1 cases happen only for addition and subtraction.
  1417.      It says that the arg that was split was really CON minus VAR.
  1418.      The rest of the code applies to all associative operations.  */
  1419.       if (!wins)
  1420.     {
  1421.       tree var, con, tem;
  1422.       int varsign;
  1423.  
  1424.       if (split_tree (arg0, code, &var, &con, &varsign))
  1425.         {
  1426.           if (varsign == -1)
  1427.         {
  1428.           /* EXPR is (CON-VAR) +- ARG1.  */
  1429.           /* If it is + and VAR==ARG1, return just CONST.  */
  1430.           if (code == PLUS_EXPR && operand_equal_p (var, arg1))
  1431.             return convert (TREE_TYPE (t), con);
  1432.             
  1433.           /* Otherwise return (CON +- ARG1) - VAR.  */
  1434.           TREE_SET_CODE (t, MINUS_EXPR);
  1435.           TREE_OPERAND (t, 1) = var;
  1436.           TREE_OPERAND (t, 0)
  1437.             = fold (build (code, TREE_TYPE (t), con, arg1));
  1438.         }
  1439.           else
  1440.         {
  1441.           /* EXPR is (VAR+CON) +- ARG1.  */
  1442.           /* If it is - and VAR==ARG1, return just CONST.  */
  1443.           if (code == MINUS_EXPR && operand_equal_p (var, arg1))
  1444.             return convert (TREE_TYPE (t), con);
  1445.             
  1446.           /* Otherwise return VAR +- (ARG1 +- CON).  */
  1447.           TREE_OPERAND (t, 1) = tem
  1448.             = fold (build (code, TREE_TYPE (t), arg1, con));
  1449.           TREE_OPERAND (t, 0) = var;
  1450.           if (integer_zerop (tem)
  1451.               && (code == PLUS_EXPR || code == MINUS_EXPR))
  1452.             return var;
  1453.           /* If we have x +/- (c - d) [c an explicit integer]
  1454.              change it to x -/+ (d - c) since if d is relocatable
  1455.              then the latter can be a single immediate insn
  1456.              and the former cannot.  */
  1457.           if (TREE_CODE (tem) == MINUS_EXPR
  1458.               && TREE_CODE (TREE_OPERAND (tem, 0)) == INTEGER_CST)
  1459.             {
  1460.               tree tem1 = TREE_OPERAND (tem, 1);
  1461.               TREE_OPERAND (tem, 1) = TREE_OPERAND (tem, 0);
  1462.               TREE_OPERAND (tem, 0) = tem1;
  1463.               TREE_SET_CODE (t,
  1464.                      (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
  1465.             }
  1466.         }
  1467.           return t;
  1468.         }
  1469.  
  1470.       if (split_tree (arg1, code, &var, &con, &varsign))
  1471.         {
  1472.           /* EXPR is ARG0 +- (CON +- VAR).  */
  1473.           if (varsign == -1)
  1474.         TREE_SET_CODE (t,
  1475.                    (code == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR));
  1476.           if (TREE_CODE (t) == MINUS_EXPR && operand_equal_p (var, arg0))
  1477.         return convert (TREE_TYPE (t), con);
  1478.           TREE_OPERAND (t, 0)
  1479.         = fold (build (code, TREE_TYPE (t), arg0, con));
  1480.           TREE_OPERAND (t, 1) = var;
  1481.           if (integer_zerop (TREE_OPERAND (t, 0))
  1482.           && TREE_CODE (t) == PLUS_EXPR)
  1483.         return convert (TREE_TYPE (t), var);
  1484.           return t;
  1485.         }
  1486.     }
  1487.     binary:
  1488. #if defined (REAL_IS_NOT_DOUBLE) && ! defined (REAL_ARITHMETIC)
  1489.       if (TREE_CODE (arg1) == REAL_CST)
  1490.     return t;
  1491. #endif /* REAL_IS_NOT_DOUBLE, and no REAL_ARITHMETIC */
  1492.       {
  1493.     register tree t1 = NULL_TREE;
  1494.     if (wins)
  1495.       t1 = combine (code, arg0, arg1);
  1496.     if (t1 != NULL_TREE) return t1;
  1497.     return t;
  1498.       }
  1499.  
  1500.     case MINUS_EXPR:
  1501.       if (! wins && integer_zerop (arg0))
  1502.     return build (NEGATE_EXPR, type, arg1);
  1503.       if (integer_zerop (arg1))
  1504.     return convert (type, arg0);
  1505.       /* Fold &x - &x.  This can happen from &x.foo - &x.  */
  1506.       if (operand_equal_p (arg0, arg1))
  1507.     return convert (TREE_TYPE (t), integer_zero_node);
  1508.       goto associate;
  1509.  
  1510.     case MULT_EXPR:
  1511.       if (!loses && integer_zerop (arg0))
  1512.     return convert (type, arg0);
  1513.       if (!loses && integer_zerop (arg1))
  1514.     return convert (type, arg1);
  1515.       if (integer_onep (arg0))
  1516.     return convert (type, arg1);
  1517.       if (integer_onep (arg1))
  1518.     return convert (type, arg0);
  1519.       goto associate;
  1520.  
  1521.     case BIT_IOR_EXPR:
  1522.       if (!loses && integer_all_onesp (arg0))
  1523.     return convert (type, arg0);
  1524.       if (!loses && integer_all_onesp (arg1))
  1525.     return convert (type, arg1);
  1526.     case BIT_XOR_EXPR:
  1527.       if (integer_zerop (arg0))
  1528.     return convert (type, arg1);
  1529.       if (integer_zerop (arg1))
  1530.     return convert (type, arg0);
  1531.       goto associate;
  1532.  
  1533.     case BIT_AND_EXPR:
  1534.       if (integer_all_onesp (arg0))
  1535.     return convert (type, arg1);
  1536.       if (integer_all_onesp (arg1))
  1537.     return convert (type, arg0);
  1538.       if (!loses && integer_zerop (arg0))
  1539.     return convert (type, arg0);
  1540.       if (!loses && integer_zerop (arg1))
  1541.     return convert (type, arg1);
  1542.       /* Simplify ((int)c & 0x377) into (int)c, if c is unsigned char.  */
  1543.       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == NOP_EXPR
  1544.       && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg1, 0))))
  1545.     {
  1546.       int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg1, 0)));
  1547.       if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
  1548.           && (~TREE_INT_CST_LOW (arg0) & ((1 << prec) - 1)) == 0)
  1549.         return build (NOP_EXPR, type, TREE_OPERAND (arg1, 0));
  1550.     }
  1551.       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
  1552.       && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
  1553.     {
  1554.       int prec = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
  1555.       if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_INT
  1556.           && (~TREE_INT_CST_LOW (arg1) & ((1 << prec) - 1)) == 0)
  1557.         return build (NOP_EXPR, type, TREE_OPERAND (arg0, 0));
  1558.     }
  1559.       goto associate;
  1560.  
  1561.     case BIT_ANDTC_EXPR:
  1562.       if (integer_all_onesp (arg0))
  1563.     return convert (type, arg1);
  1564.       if (integer_zerop (arg1))
  1565.     return convert (type, arg0);
  1566.       if (!loses && integer_zerop (arg0))
  1567.     return convert (type, arg0);
  1568.       if (!loses && integer_all_onesp (arg1))
  1569.     return combine (code, arg1, arg1);
  1570.       goto binary;
  1571.  
  1572.     case TRUNC_DIV_EXPR:
  1573.     case ROUND_DIV_EXPR:
  1574.     case FLOOR_DIV_EXPR:
  1575.     case CEIL_DIV_EXPR:
  1576.     case EXACT_DIV_EXPR:
  1577.     case RDIV_EXPR:
  1578.       if (integer_onep (arg1))
  1579.     return convert (type, arg0);
  1580.       if (integer_zerop (arg1))
  1581.     return t;
  1582. #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
  1583.       if (TREE_CODE (arg1) == REAL_CST
  1584.       && real_zerop (arg1))
  1585.     return t;
  1586. #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
  1587.  
  1588.       goto binary;
  1589.  
  1590.     case CEIL_MOD_EXPR:
  1591.     case FLOOR_MOD_EXPR:
  1592.     case ROUND_MOD_EXPR:
  1593.     case TRUNC_MOD_EXPR:
  1594.       if (!loses && integer_onep (arg1))
  1595.     return combine (code, arg1, arg1);
  1596.       if (integer_zerop (arg1))
  1597.     return t;
  1598.       goto binary;
  1599.  
  1600.     case LSHIFT_EXPR:
  1601.     case RSHIFT_EXPR:
  1602.     case LROTATE_EXPR:
  1603.     case RROTATE_EXPR:
  1604.       if (integer_zerop (arg1))
  1605.     return convert (type, arg0);
  1606.       goto binary;
  1607.  
  1608.     case MIN_EXPR: case MAX_EXPR:
  1609.       goto associate;
  1610.  
  1611.     case TRUTH_NOT_EXPR:
  1612.       /* Note that the operand of this must be an int
  1613.      and its values must be 0 or 1.
  1614.      ("true" is a fixed value perhaps depending on the language,
  1615.      but we don't handle values other than 1 correctly yet.)  */
  1616.       if (TREE_CODE (arg0) == INTEGER_CST)
  1617.     {
  1618.       t = build_int_2 ((TREE_INT_CST_LOW (arg0) == 0
  1619.                 && TREE_INT_CST_HIGH (arg0) == 0),
  1620.                0);
  1621.       TREE_TYPE (t) = integer_type_node;
  1622.     }
  1623.       return t;
  1624.  
  1625.     case TRUTH_ANDIF_EXPR:
  1626.       /* Note that the operands of this must be ints
  1627.      and their values must be 0 or 1.
  1628.      ("true" is a fixed value perhaps depending on the language.)  */
  1629.       /* If first arg is constant zero, return it.  */
  1630.       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
  1631.     return arg0;
  1632.     case TRUTH_AND_EXPR:
  1633.       /* If either arg is constant true, drop it.  */
  1634.       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
  1635.     return arg1;
  1636.       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
  1637.     return arg0;
  1638.       /* Both known to be zero => return zero.  */
  1639.       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
  1640.     return arg0;
  1641.       return t;
  1642.  
  1643.     case TRUTH_ORIF_EXPR:
  1644.       /* Note that the operands of this must be ints
  1645.      and their values must be 0 or true.
  1646.      ("true" is a fixed value perhaps depending on the language.)  */
  1647.       /* If first arg is constant true, return it.  */
  1648.       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
  1649.     return arg0;
  1650.     case TRUTH_OR_EXPR:
  1651.       /* If either arg is constant zero, drop it.  */
  1652.       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
  1653.     return arg1;
  1654.       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1))
  1655.     return arg0;
  1656.       /* Both known to be true => return true.  */
  1657.       if (TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
  1658.     return arg0;
  1659.       return t;
  1660.  
  1661.     case EQ_EXPR:
  1662.     case NE_EXPR:
  1663.     case LT_EXPR:
  1664.     case GT_EXPR:
  1665.     case LE_EXPR:
  1666.     case GE_EXPR:
  1667.       /* If one arg is a constant integer, put it last.  */
  1668.       if (TREE_CODE (arg0) == INTEGER_CST
  1669.       && TREE_CODE (arg1) != INTEGER_CST)
  1670.     {
  1671.       TREE_OPERAND (t, 0) = arg1;
  1672.       TREE_OPERAND (t, 1) = arg0;
  1673.       arg0 = TREE_OPERAND (t, 0);
  1674.       arg1 = TREE_OPERAND (t, 1);
  1675.       switch (code)
  1676.         {
  1677.         case GT_EXPR:
  1678.           code = LT_EXPR;
  1679.           break;
  1680.         case GE_EXPR:
  1681.           code = LE_EXPR;
  1682.           break;
  1683.         case LT_EXPR:
  1684.           code = GT_EXPR;
  1685.           break;
  1686.         case LE_EXPR:
  1687.           code = GE_EXPR;
  1688.           break;
  1689.         }
  1690.       TREE_SET_CODE (t, code);
  1691.     }
  1692.  
  1693.       /* Convert foo++ == CONST into ++foo == CONST + INCR.
  1694.      First, see if one arg is constant; find the constant arg
  1695.      and the other one.  */
  1696.       {
  1697.     tree constop = 0, varop;
  1698.     tree *constoploc;
  1699.  
  1700.     if (TREE_LITERAL (arg1))
  1701.       constoploc = &TREE_OPERAND (t, 1), constop = arg1, varop = arg0;
  1702.     if (TREE_LITERAL (arg0))
  1703.       constoploc = &TREE_OPERAND (t, 0), constop = arg0, varop = arg1;
  1704.  
  1705.     if (constop && TREE_CODE (varop) == POSTINCREMENT_EXPR)
  1706.       {
  1707.         tree newconst
  1708.           = fold (build (PLUS_EXPR, TREE_TYPE (constop),
  1709.                  constop, TREE_OPERAND (varop, 1)));
  1710.         /* This optimization is invalid for ordered comparisons
  1711.            if CONST+INCR overflows or if foo+incr might overflow.
  1712.            For pointer types we assume overflow doesn't happen.  */
  1713.         if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
  1714.         || code == EQ_EXPR || code == NE_EXPR)
  1715.           {
  1716.         TREE_SET_CODE (varop, PREINCREMENT_EXPR);
  1717.         *constoploc = newconst;
  1718.         return t;
  1719.           }
  1720.       }
  1721.     else if (constop && TREE_CODE (varop) == POSTDECREMENT_EXPR)
  1722.       {
  1723.         tree newconst
  1724.           = fold (build (MINUS_EXPR, TREE_TYPE (constop),
  1725.                  constop, TREE_OPERAND (varop, 1)));
  1726.         if (TREE_CODE (TREE_TYPE (varop)) == POINTER_TYPE
  1727.         || code == EQ_EXPR || code == NE_EXPR)
  1728.           {
  1729.         TREE_SET_CODE (varop, PREDECREMENT_EXPR);
  1730.         *constoploc = newconst;
  1731.         return t;
  1732.           }
  1733.       }
  1734.       }
  1735.  
  1736.       /* Change X >= CST to X > (CST - 1) if CST is positive.  */
  1737.       if (TREE_CODE (arg1) == INTEGER_CST
  1738.       && TREE_CODE (arg0) != INTEGER_CST
  1739.       && ! tree_int_cst_lt (arg1, integer_one_node))
  1740.     {
  1741.       switch (TREE_CODE (t))
  1742.         {
  1743.         case GE_EXPR:
  1744.           code = GT_EXPR;
  1745.           TREE_SET_CODE (t, code);
  1746.           arg1 = combine (MINUS_EXPR, arg1, integer_one_node);
  1747.           TREE_OPERAND (t, 1) = arg1;
  1748.           break;
  1749.  
  1750.         case LT_EXPR:
  1751.           code = LE_EXPR;
  1752.           TREE_SET_CODE (t, code);
  1753.           arg1 = combine (MINUS_EXPR, arg1, integer_one_node);
  1754.           TREE_OPERAND (t, 1) = arg1;
  1755.         }
  1756.     }
  1757.  
  1758.       /* An unsigned comparison against 0 can be simplified.  */
  1759.       if (integer_zerop (arg1)
  1760.       && (TREE_CODE (TREE_TYPE (arg1)) == INTEGER_TYPE
  1761.           || TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE)
  1762.       && TREE_UNSIGNED (TREE_TYPE (arg1)))
  1763.     {
  1764.       switch (TREE_CODE (t))
  1765.         {
  1766.         case GT_EXPR:
  1767.           TREE_SET_CODE (t, NE_EXPR);
  1768.           break;
  1769.         case LE_EXPR:
  1770.           TREE_SET_CODE (t, EQ_EXPR);
  1771.           break;
  1772.         case GE_EXPR:
  1773.           return build (COMPOUND_EXPR, integer_type_node,
  1774.                 arg0, integer_one_node);
  1775.         case LT_EXPR:
  1776.           return build (COMPOUND_EXPR, integer_type_node,
  1777.                 arg0, integer_zero_node);
  1778.         }
  1779.     }
  1780.  
  1781.       /* To compute GT, swap the arguments and do LT.
  1782.      To compute GE, do LT and invert the result.
  1783.      To compute LE, swap the arguments, do LT and invert the result.
  1784.      To compute NE, do EQ and invert the result.  */
  1785.       if (code == LE_EXPR || code == GT_EXPR)
  1786.     {
  1787.       register tree temp = arg0;
  1788.       arg0 = arg1;
  1789.       arg1 = temp;
  1790.     }
  1791.  
  1792.       /* Compute a result for LT or EQ if args permit;
  1793.      otherwise return T.  */
  1794.       if (TREE_CODE (arg0) == INTEGER_CST
  1795.       && TREE_CODE (arg1) == INTEGER_CST)
  1796.     {
  1797.       if (code == EQ_EXPR || code == NE_EXPR)
  1798.         t = build_int_2
  1799.           (TREE_INT_CST_LOW (arg0) == TREE_INT_CST_LOW (arg1)
  1800.            && TREE_INT_CST_HIGH (arg0) == TREE_INT_CST_HIGH (arg1),
  1801.            0);
  1802.       else
  1803.         t = build_int_2 ((TREE_UNSIGNED (TREE_TYPE (arg0))
  1804.                   ? INT_CST_LT_UNSIGNED (arg0, arg1)
  1805.                   : INT_CST_LT (arg0, arg1)),
  1806.                  0);
  1807.     }
  1808.       else if (TREE_CODE (arg1) == INTEGER_CST
  1809.            && TREE_LITERAL (arg0)
  1810.            && TREE_CODE (arg0) == ADDR_EXPR
  1811.            && (code == EQ_EXPR || code == NE_EXPR))
  1812.     {
  1813.       t = build_int_2 (0, 0);
  1814.     }
  1815.       else if (TREE_CODE (arg0) == REAL_CST
  1816.            && TREE_CODE (arg1) == REAL_CST)
  1817.     {
  1818.       if (code == EQ_EXPR || code == NE_EXPR)
  1819.         t = build_int_2 (REAL_VALUES_EQUAL (TREE_REAL_CST (arg0),
  1820.                         TREE_REAL_CST (arg1)),
  1821.                  0);
  1822.       else
  1823.         t = build_int_2 (REAL_VALUES_LESS (TREE_REAL_CST (arg0),
  1824.                            TREE_REAL_CST (arg1)),
  1825.                  0);
  1826.     }
  1827.       else
  1828.     return t;
  1829.  
  1830.       /* If what we want is other than LT or EQ, invert the result.  */
  1831.       if (code == GE_EXPR || code == LE_EXPR || code == NE_EXPR)
  1832.     TREE_INT_CST_LOW (t) ^= 1;
  1833.       TREE_TYPE (t) = type;
  1834.       return t;
  1835.  
  1836.     case COND_EXPR:
  1837.       if (TREE_LITERAL (arg0))
  1838.     return TREE_OPERAND (expr, (integer_zerop (arg0) ? 2 : 1));
  1839.       return t;
  1840.  
  1841.     default:
  1842.       return t;
  1843.     } /* switch (code) */
  1844. }
  1845.